Networked processors are typical in modern telecommunications systems and other systems in which a plurality of servers or other processors are interconnected by one or more networks and are individually configured to run instances of the same application software, where this set of processors is sometimes referred to as a cluster. The use of clustered processors is particularly advantageous for high availability systems such as telecommunications, e-commerce, and other situations in which a network can accommodate a potentially large number of application instances. A cluster can include high availability software and provide for application redundancy schemes/approaches using processors of the cluster, where the high availability software can be part of the application software and/or may be separate code, such as middleware. In telecommunications systems, such clusters are found in a variety of situations, such as server banks providing radio network controller (RNC) functions associated with base station controllers in a wireless network, where each application processor (AP) may be running an instance of the same application for managing access network resources such as radios and channels, as well as to manage call processing, signaling, data traffic processing, etc.
As application software evolves, new versions are produced, whether major version updates or upgrades to fix bugs and/or retrofits to add new features, where the new version of a given application may change interfaces between elements or add new interfaces/processes or otherwise create a compatibility issue with respect to a previous version. In these situations, it is desirable or necessary to ensure that either the new software update or retrofit is completely backward compatible, or that all the processors in the cluster are updated or retrofitted at the same time, i.e., that two incompatible versions are not running on different processors at the same time in an active cluster. In addressing the ever-changing landscape of software application functionality, it is costly and difficult to design new software to be backward compatible with previous versions. Thus, many new software versions, particularly those that add or change interfaces among components, are not backward compatible. In this situation, one approach is to take all the processors off-line (i.e., shutdown the service providing application) and perform software updates/retrofits at once. However, in telecommunications systems and other applications, extended downtime is undesirable, even if planned. Furthermore, it may be undesirable in high availability situations to perform a complete software version update or retrofit all at once in case there are problems with the new version. Thus, there remains a need for improved methods and systems for updating or retrofitting software applications in a cluster of processors running an application to service clients by which the difficulties associated with non-backward compatible software can be mitigated or overcome without excessive system downtime.